﻿using System;
using System.Collections.Generic;
using System.Linq;
using Common;
using IBll.Sys;
using Model.Sys;
using ServiceStack.Redis;

namespace Bll.Sys
{
    //public class RedisCacheBll : ICacheBll
    //{
    //    public bool Add<T>(string key, T value)
    //    {
    //        Cache<T> cache = new Cache<T>();

    //        cache.CreateTime = DateTime.Now;
    //        cache.FailureTime = DateTime.MaxValue;
    //        cache.Value = value;
    //        return RedisCacheHelper.Set(key, cache);
    //    }

    //    public bool Add<T>(string key, T value, DateTime expireTime)
    //    {
    //        Cache<T> cache = new Cache<T>();

    //        cache.CreateTime = DateTime.Now;
    //        cache.FailureTime = expireTime;
    //        cache.Value = value;
    //        return RedisCacheHelper.Set(key, cache, expireTime);
    //    }

    //    public bool Remove(string key)
    //    {
    //        return RedisCacheHelper.Remove(key);
    //    }

    //    public bool Remove(List<string> keys)
    //    {
    //        bool result = true;

    //        try
    //        {
    //            RedisCacheHelper.Remove(keys);
    //        }
    //        catch (Exception ex)
    //        {
    //            result = false;
    //        }

    //        return result;
    //    }

    //    public bool Remove()
    //    {
    //        bool result = true;

    //        try
    //        {
    //            RedisCacheHelper.RemoveAll();
    //        }
    //        catch (Exception ex)
    //        {
    //            result = false;
    //        }

    //        return result;
    //    }

    //    public bool Update<T>(string key, T value)
    //    {
    //        return RedisCacheHelper.Update(key, value);
    //    }

    //    public int GetCount()
    //    {
    //        return RedisCacheHelper.GetCacheCount();
    //    }

    //    public bool IsExists(string key)
    //    {
    //        return RedisCacheHelper.IsExists(key);
    //    }

    //    public Cache<T> GetCache<T>(string key)
    //    {
    //        return RedisCacheHelper.Get<Cache<T>>(key);
    //    }
    //}


















    //#region Redis帮助类
    //public class RedisCacheHelper
    //{
    //    #region -- 连接信息 --
    //    /// <summary>
    //    /// redis连接池客户端管理对象
    //    /// </summary>
    //    private static PooledRedisClientManager prcm;

    //    /// <summary>
    //    /// 静态构造方法，初始化链接池管理对象
    //    /// </summary>
    //    static RedisCacheHelper()
    //    {
    //        string[] writeServerList = SplitString(Model.Sys.Config.RedisConfig.WriteServerList, ",");
    //        string[] readServerList = SplitString(Model.Sys.Config.RedisConfig.ReadServerList, ",");
    //        prcm = new PooledRedisClientManager(
    //            writeServerList,
    //            readServerList,
    //            new RedisClientManagerConfig
    //            {
    //                MaxWritePoolSize = Model.Sys.Config.RedisConfig.MaxWritePoolSize,
    //                MaxReadPoolSize = Model.Sys.Config.RedisConfig.MaxReadPoolSize,
    //                AutoStart = Model.Sys.Config.RedisConfig.AutoStart,
    //            }
    //        );
    //    }

    //    private static string[] SplitString(string strSource, string split)
    //    {
    //        return strSource.Split(split.ToArray());
    //    }
    //    #endregion


    //    #region -- Item --（主要运用这个）
    //    /// <summary>
    //    /// 设置单体(永不过期)
    //    /// </summary>
    //    /// <typeparam name="T"></typeparam>
    //    /// <param name="key"></param>
    //    /// <param name="t"></param>
    //    /// <param name="timeSpan"></param>
    //    /// <returns></returns>
    //    public static bool Set<T>(string key, T t)
    //    {
    //        using (IRedisClient redis = prcm.GetClient())
    //        {
    //            DateTime expireTime = DateTime.MaxValue;
    //            return redis.Set<T>(key, t, expireTime);
    //        }
    //    }
    //    /// <summary>
    //    /// 设置单体
    //    /// </summary>
    //    /// <typeparam name="T"></typeparam>
    //    /// <param name="key"></param>
    //    /// <param name="t"></param>
    //    /// <param name="timeSpan"></param>
    //    /// <returns></returns>
    //    public static bool Set<T>(string key, T t, TimeSpan timeSpan)
    //    {
    //        using (IRedisClient redis = prcm.GetClient())
    //        {
    //            return redis.Set<T>(key, t, timeSpan);
    //        }
    //    }
    //    /// <summary>
    //    /// 设置单体
    //    /// </summary>
    //    /// <typeparam name="T"></typeparam>
    //    /// <param name="key"></param>
    //    /// <param name="t"></param>
    //    /// <param name="dateTime"></param>
    //    /// <returns></returns>
    //    public static bool Set<T>(string key, T t, DateTime dateTime)
    //    {
    //        using (IRedisClient redis = prcm.GetClient())
    //        {
    //            return redis.Set<T>(key, t, dateTime);
    //        }
    //    }

    //    /// <summary>
    //    /// 获取单体
    //    /// </summary>
    //    /// <typeparam name="T"></typeparam>
    //    /// <param name="key"></param>
    //    /// <returns></returns>
    //    public static T Get<T>(string key) where T : class
    //    {
    //        using (IRedisClient redis = prcm.GetClient())
    //        {
    //            return redis.Get<T>(key);
    //        }
    //    }

    //    /// <summary>
    //    /// 移除单体
    //    /// </summary>
    //    /// <param name="key"></param>
    //    public static bool Remove(string key)
    //    {
    //        using (IRedisClient redis = prcm.GetClient())
    //        {
    //            return redis.Remove(key);
    //        }
    //    }

    //    /// <summary>
    //    /// 移除单体集合         Add By Txy 2018-1-18
    //    /// </summary>
    //    /// <param name="key"></param>
    //    public static void Remove(IList<string> key)
    //    {
    //        try
    //        {
    //            using (IRedisClient redis = prcm.GetClient())
    //            {
    //                redis.RemoveAll(key);
    //            }
    //        }
    //        catch (Exception ex)
    //        {
    //            throw ex;
    //        }
    //    }

    //    /// <summary>
    //    /// 清空所有缓存
    //    /// </summary>
    //    public static void RemoveAll()
    //    {
    //        try
    //        {
    //            using (IRedisClient redis = prcm.GetClient())
    //            {
    //                redis.FlushAll();
    //            }
    //        }
    //        catch (Exception ex)
    //        {
    //            throw ex;
    //        }
    //    }

    //    /// <summary>
    //    /// 更新key值对应的缓存   Add  By tongqing 20161014
    //    /// </summary>
    //    public static bool Update<T>(string key, T value)
    //    {
    //        using (IRedisClient redis = prcm.GetClient())
    //        {
    //            Cache<T> oldCache = redis.Get<Cache<T>>(key);

    //            if (oldCache != null)
    //            {
    //                oldCache.Value = value;
    //                return redis.Replace(key, oldCache);
    //            }
    //            else
    //            {
    //                return false;
    //            }
    //        }
    //    }

    //    /// <summary>
    //    /// 获取缓存数
    //    /// </summary>
    //    /// <returns></returns>
    //    public static int GetCacheCount()
    //    {
    //        int count = 0;

    //        using (IRedisClient redis = prcm.GetClient())
    //        {
    //            count = redis.GetAllKeys().Count;
    //        }

    //        return count;
    //    }

    //    /// <summary>
    //    /// 是否存在key值对应的缓存   Add  By tongqing 20161014
    //    /// </summary>
    //    public static bool IsExists(string key)
    //    {
    //        using (IRedisClient redis = prcm.GetClient())
    //        {
    //            return redis.ContainsKey(key);
    //        }
    //    }
    //    #endregion

    //    #region -- List --

    //    //public static void List_Add<T>(string key, T t)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {

    //    //        var redisTypedClient = redis.As<T>();
    //    //        redisTypedClient.AddItemToList(redisTypedClient.Lists[key], t);
    //    //    }
    //    //}



    //    //public static bool List_Remove<T>(string key, T t)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        var redisTypedClient = redis.As<T>();
    //    //        return redisTypedClient.RemoveItemFromList(redisTypedClient.Lists[key], t) > 0;
    //    //    }
    //    //}
    //    //public static void List_RemoveAll<T>(string key)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        var redisTypedClient = redis.As<T>();
    //    //        redisTypedClient.Lists[key].RemoveAll();
    //    //    }
    //    //}

    //    //public static long List_Count(string key)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        return redis.GetListCount(key);
    //    //    }
    //    //}

    //    //public static List<T> List_GetRange<T>(string key, int start, int count)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        var c = redis.As<T>();
    //    //        return c.Lists[key].GetRange(start, start + count - 1);
    //    //    }
    //    //}


    //    //public static List<T> List_GetList<T>(string key)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        var c = redis.As<T>();
    //    //        return c.Lists[key].GetRange(0, c.Lists[key].Count);
    //    //    }
    //    //}

    //    //public static List<T> List_GetList<T>(string key, int pageIndex, int pageSize)
    //    //{
    //    //    int start = pageSize * (pageIndex - 1);
    //    //    return List_GetRange<T>(key, start, pageSize);
    //    //}

    //    ///// <summary>
    //    ///// 设置缓存过期
    //    ///// </summary>
    //    ///// <param name="key"></param>
    //    ///// <param name="datetime"></param>
    //    //public static void List_SetExpire(string key, DateTime datetime)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        redis.ExpireEntryAt(key, datetime);
    //    //    }
    //    //}
    //    #endregion

    //    #region -- Set --
    //    //public static void Set_Add<T>(string key, T t)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        var redisTypedClient = redis.As<T>();
    //    //        redisTypedClient.Sets[key].Add(t);
    //    //    }
    //    //}
    //    //public static bool Set_Contains<T>(string key, T t)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        var redisTypedClient = redis.As<T>();
    //    //        return redisTypedClient.Sets[key].Contains(t);
    //    //    }
    //    //}
    //    //public static bool Set_Remove<T>(string key, T t)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        var redisTypedClient = redis.As<T>();
    //    //        return redisTypedClient.Sets[key].Remove(t);
    //    //    }
    //    //}
    //    #endregion

    //    #region -- Hash --
    //    ///// <summary>
    //    ///// 判断某个数据是否已经被缓存
    //    ///// </summary>
    //    ///// <typeparam name="T"></typeparam>
    //    ///// <param name="key"></param>
    //    ///// <param name="dataKey"></param>
    //    ///// <returns></returns>
    //    //public static bool Hash_Exist<T>(string key, string dataKey)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        return redis.HashContainsEntry(key, dataKey);
    //    //    }
    //    //}

    //    ///// <summary>
    //    ///// 存储数据到hash表
    //    ///// </summary>
    //    ///// <typeparam name="T"></typeparam>
    //    ///// <param name="key"></param>
    //    ///// <param name="dataKey"></param>
    //    ///// <returns></returns>
    //    //public static bool Hash_Set<T>(string key, string dataKey, T t)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
    //    //        return redis.SetEntryInHash(key, dataKey, value);
    //    //    }
    //    //}
    //    ///// <summary>
    //    ///// 移除hash中的某值
    //    ///// </summary>
    //    ///// <typeparam name="T"></typeparam>
    //    ///// <param name="key"></param>
    //    ///// <param name="dataKey"></param>
    //    ///// <returns></returns>
    //    //public static bool Hash_Remove(string key, string dataKey)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        return redis.RemoveEntryFromHash(key, dataKey);
    //    //    }
    //    //}
    //    ///// <summary>
    //    ///// 移除整个hash
    //    ///// </summary>
    //    ///// <typeparam name="T"></typeparam>
    //    ///// <param name="key"></param>
    //    ///// <param name="dataKey"></param>
    //    ///// <returns></returns>
    //    //public static bool Hash_Remove(string key)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        return redis.Remove(key);
    //    //    }
    //    //}
    //    ///// <summary>
    //    ///// 从hash表获取数据
    //    ///// </summary>
    //    ///// <typeparam name="T"></typeparam>
    //    ///// <param name="key"></param>
    //    ///// <param name="dataKey"></param>
    //    ///// <returns></returns>
    //    //public static T Hash_Get<T>(string key, string dataKey)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        string value = redis.GetValueFromHash(key, dataKey);
    //    //        return ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(value);
    //    //    }
    //    //}
    //    ///// <summary>
    //    ///// 获取整个hash的数据
    //    ///// </summary>
    //    ///// <typeparam name="T"></typeparam>
    //    ///// <param name="key"></param>
    //    ///// <returns></returns>
    //    //public static List<T> Hash_GetAll<T>(string key)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        var list = redis.GetHashValues(key);
    //    //        if (list != null && list.Count > 0)
    //    //        {
    //    //            List<T> result = new List<T>();
    //    //            foreach (var item in list)
    //    //            {
    //    //                var value = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
    //    //                result.Add(value);
    //    //            }
    //    //            return result;
    //    //        }
    //    //        return null;
    //    //    }
    //    //}
    //    ///// <summary>
    //    ///// 设置缓存过期
    //    ///// </summary>
    //    ///// <param name="key"></param>
    //    ///// <param name="datetime"></param>
    //    //public static void Hash_SetExpire(string key, DateTime datetime)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        redis.ExpireEntryAt(key, datetime);
    //    //    }
    //    //}
    //    #endregion

    //    #region -- SortedSet --
    //    ///// <summary>
    //    /////  添加数据到 SortedSet
    //    ///// </summary>
    //    ///// <typeparam name="T"></typeparam>
    //    ///// <param name="key"></param>
    //    ///// <param name="t"></param>
    //    ///// <param name="score"></param>
    //    //public static bool SortedSet_Add<T>(string key, T t, double score)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
    //    //        return redis.AddItemToSortedSet(key, value, score);
    //    //    }
    //    //}
    //    ///// <summary>
    //    ///// 移除数据从SortedSet
    //    ///// </summary>
    //    ///// <typeparam name="T"></typeparam>
    //    ///// <param name="key"></param>
    //    ///// <param name="t"></param>
    //    ///// <returns></returns>
    //    //public static bool SortedSet_Remove<T>(string key, T t)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
    //    //        return redis.RemoveItemFromSortedSet(key, value);
    //    //    }
    //    //}
    //    ///// <summary>
    //    ///// 修剪SortedSet
    //    ///// </summary>
    //    ///// <param name="key"></param>
    //    ///// <param name="size">保留的条数</param>
    //    ///// <returns></returns>
    //    //public static long SortedSet_Trim(string key, int size)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        return redis.RemoveRangeFromSortedSet(key, size, 9999999);
    //    //    }
    //    //}
    //    ///// <summary>
    //    ///// 获取SortedSet的长度
    //    ///// </summary>
    //    ///// <param name="key"></param>
    //    ///// <returns></returns>
    //    //public static long SortedSet_Count(string key)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        return redis.GetSortedSetCount(key);
    //    //    }
    //    //}

    //    ///// <summary>
    //    ///// 获取SortedSet的分页数据
    //    ///// </summary>
    //    ///// <typeparam name="T"></typeparam>
    //    ///// <param name="key"></param>
    //    ///// <param name="pageIndex"></param>
    //    ///// <param name="pageSize"></param>
    //    ///// <returns></returns>
    //    //public static List<T> SortedSet_GetList<T>(string key, int pageIndex, int pageSize)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        var list = redis.GetRangeFromSortedSet(key, (pageIndex - 1) * pageSize, pageIndex * pageSize - 1);
    //    //        if (list != null && list.Count > 0)
    //    //        {
    //    //            List<T> result = new List<T>();
    //    //            foreach (var item in list)
    //    //            {
    //    //                var data = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
    //    //                result.Add(data);
    //    //            }
    //    //            return result;
    //    //        }
    //    //    }
    //    //    return null;
    //    //}


    //    ///// <summary>
    //    ///// 获取SortedSet的全部数据
    //    ///// </summary>
    //    ///// <typeparam name="T"></typeparam>
    //    ///// <param name="key"></param>
    //    ///// <param name="pageIndex"></param>
    //    ///// <param name="pageSize"></param>
    //    ///// <returns></returns>
    //    //public static List<T> SortedSet_GetListALL<T>(string key)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        var list = redis.GetRangeFromSortedSet(key, 0, 9999999);
    //    //        if (list != null && list.Count > 0)
    //    //        {
    //    //            List<T> result = new List<T>();
    //    //            foreach (var item in list)
    //    //            {
    //    //                var data = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
    //    //                result.Add(data);
    //    //            }
    //    //            return result;
    //    //        }
    //    //    }
    //    //    return null;
    //    //}

    //    ///// <summary>
    //    ///// 设置缓存过期
    //    ///// </summary>
    //    ///// <param name="key"></param>
    //    ///// <param name="datetime"></param>
    //    //public static void SortedSet_SetExpire(string key, DateTime datetime)
    //    //{
    //    //    using (IRedisClient redis = prcm.GetClient())
    //    //    {
    //    //        redis.ExpireEntryAt(key, datetime);
    //    //    }
    //    //}
    //    #endregion

    //}
    //#endregion
}
